home *** CD-ROM | disk | FTP | other *** search
/ Freelog 125 / Freelog_MarsAvril2015_No125.iso / Musique / Quod Libet / quodlibet-3.3.0-installer.exe / bin / encodings / punycode.pyc (.txt) < prev    next >
Python Compiled Bytecode  |  2014-12-31  |  8KB  |  252 lines
  1. # Source Generated with Decompyle++
  2. # File: in.pyc (Python 2.7)
  3.  
  4. ''' Codec for the Punicode encoding, as specified in RFC 3492
  5.  
  6. Written by Martin v. L\xf6wis.
  7. '''
  8. import codecs
  9.  
  10. def segregate(str):
  11.     '''3.1 Basic code point segregation'''
  12.     base = []
  13.     extended = { }
  14.     for c in str:
  15.         if ord(c) < 128:
  16.             base.append(c)
  17.             continue
  18.         extended[c] = 1
  19.     
  20.     extended = extended.keys()
  21.     extended.sort()
  22.     return (''.join(base).encode('ascii'), extended)
  23.  
  24.  
  25. def selective_len(str, max):
  26.     '''Return the length of str, considering only characters below max.'''
  27.     res = 0
  28.     for c in str:
  29.         if ord(c) < max:
  30.             res += 1
  31.             continue
  32.     return res
  33.  
  34.  
  35. def selective_find(str, char, index, pos):
  36.     '''Return a pair (index, pos), indicating the next occurrence of
  37.     char in str. index is the position of the character considering
  38.     only ordinals up to and including char, and pos is the position in
  39.     the full string. index/pos is the starting position in the full
  40.     string.'''
  41.     l = len(str)
  42.     while None:
  43.         pos += 1
  44.         if pos == l:
  45.             return (-1, -1)
  46.         c = None[pos]
  47.         if c == char:
  48.             return (index + 1, pos)
  49.         if None < char:
  50.             index += 1
  51.             continue
  52.             continue
  53.             return None
  54.  
  55.  
  56. def insertion_unsort(str, extended):
  57.     '''3.2 Insertion unsort coding'''
  58.     oldchar = 128
  59.     result = []
  60.     oldindex = -1
  61.     for c in extended:
  62.         index = pos = -1
  63.         char = ord(c)
  64.         curlen = selective_len(str, char)
  65.         delta = (curlen + 1) * (char - oldchar)
  66.         while None:
  67.             (index, pos) = selective_find(str, c, index, pos)
  68.             if index == -1:
  69.                 break
  70.             delta += index - oldindex
  71.             oldindex = index
  72.             delta = 0
  73.             continue
  74.             oldchar = char
  75.     return result
  76.  
  77.  
  78. def T(j, bias):
  79.     res = 36 * (j + 1) - bias
  80.     if res < 1:
  81.         return 1
  82.     if None > 26:
  83.         return 26
  84.  
  85. digits = 'abcdefghijklmnopqrstuvwxyz0123456789'
  86.  
  87. def generate_generalized_integer(N, bias):
  88.     '''3.3 Generalized variable-length integers'''
  89.     result = []
  90.     j = 0
  91.     while None:
  92.         t = T(j, bias)
  93.         if N < t:
  94.             result.append(digits[N])
  95.             return result
  96.         N = (N - t) // (36 - t)
  97.         j += 1
  98.         continue
  99.         return None
  100.  
  101.  
  102. def adapt(delta, first, numchars):
  103.     if first:
  104.         delta //= 700
  105.     else:
  106.         delta //= 2
  107.     delta += delta // numchars
  108.     divisions = 0
  109.     while delta > 455:
  110.         delta = delta // 35
  111.         divisions += 36
  112.     bias = divisions + 36 * delta // (delta + 38)
  113.     return bias
  114.  
  115.  
  116. def generate_integers(baselen, deltas):
  117.     '''3.4 Bias adaptation'''
  118.     result = []
  119.     bias = 72
  120.     for points, delta in enumerate(deltas):
  121.         s = generate_generalized_integer(delta, bias)
  122.         result.extend(s)
  123.         bias = adapt(delta, points == 0, baselen + points + 1)
  124.     
  125.     return ''.join(result)
  126.  
  127.  
  128. def punycode_encode(text):
  129.     (base, extended) = segregate(text)
  130.     base = base.encode('ascii')
  131.     deltas = insertion_unsort(text, extended)
  132.     extended = generate_integers(len(base), deltas)
  133.     if base:
  134.         return base + '-' + extended
  135.  
  136.  
  137. def decode_generalized_number(extended, extpos, bias, errors):
  138.     '''3.3 Generalized variable-length integers'''
  139.     result = 0
  140.     w = 1
  141.     j = 0
  142.     while None:
  143.         
  144.         try:
  145.             char = ord(extended[extpos])
  146.         except IndexError:
  147.             if errors == 'strict':
  148.                 raise UnicodeError, 'incomplete punicode string'
  149.             return (extpos + 1, None)
  150.  
  151.         extpos += 1
  152.         if char <= char:
  153.             pass
  154.         elif char <= 90:
  155.             digit = char - 65
  156.         elif char <= char:
  157.             pass
  158.         elif char <= char <= 57:
  159.             digit = char - 22
  160.         elif errors == 'strict':
  161.             raise UnicodeError("Invalid extended code point '%s'" % extended[extpos])
  162.         else:
  163.             return (extpos, None)
  164.         t = char <= 90(j, bias)
  165.         result += digit * w
  166.         if digit < t:
  167.             return (extpos, result)
  168.         w = 65 * (36 - t)
  169.         j += 1
  170.         continue
  171.         return None
  172.  
  173.  
  174. def insertion_sort(base, extended, errors):
  175.     '''3.2 Insertion unsort coding'''
  176.     char = 128
  177.     pos = -1
  178.     bias = 72
  179.     extpos = 0
  180.     while extpos < len(extended):
  181.         (newpos, delta) = decode_generalized_number(extended, extpos, bias, errors)
  182.         if delta is None:
  183.             return base
  184.         None += delta + 1
  185.         char += pos // (len(base) + 1)
  186.         if char > 1114111:
  187.             if errors == 'strict':
  188.                 raise UnicodeError, 'Invalid character U+%x' % char
  189.             char = ord('?')
  190.         pos = pos % (len(base) + 1)
  191.         base = base[:pos] + unichr(char) + base[pos:]
  192.         bias = adapt(delta, extpos == 0, len(base))
  193.         extpos = newpos
  194.     return base
  195.  
  196.  
  197. def punycode_decode(text, errors):
  198.     pos = text.rfind('-')
  199.     if pos == -1:
  200.         base = ''
  201.         extended = text
  202.     else:
  203.         base = text[:pos]
  204.         extended = text[pos + 1:]
  205.     base = unicode(base, 'ascii', errors)
  206.     extended = extended.upper()
  207.     return insertion_sort(base, extended, errors)
  208.  
  209.  
  210. class Codec(codecs.Codec):
  211.     
  212.     def encode(self, input, errors = 'strict'):
  213.         res = punycode_encode(input)
  214.         return (res, len(input))
  215.  
  216.     
  217.     def decode(self, input, errors = 'strict'):
  218.         if errors not in ('strict', 'replace', 'ignore'):
  219.             raise UnicodeError, 'Unsupported error handling ' + errors
  220.         res = punycode_decode(input, errors)
  221.         return (res, len(input))
  222.  
  223.  
  224.  
  225. class IncrementalEncoder(codecs.IncrementalEncoder):
  226.     
  227.     def encode(self, input, final = False):
  228.         return punycode_encode(input)
  229.  
  230.  
  231.  
  232. class IncrementalDecoder(codecs.IncrementalDecoder):
  233.     
  234.     def decode(self, input, final = False):
  235.         if self.errors not in ('strict', 'replace', 'ignore'):
  236.             raise UnicodeError, 'Unsupported error handling ' + self.errors
  237.         return punycode_decode(input, self.errors)
  238.  
  239.  
  240.  
  241. class StreamWriter(Codec, codecs.StreamWriter):
  242.     pass
  243.  
  244.  
  245. class StreamReader(Codec, codecs.StreamReader):
  246.     pass
  247.  
  248.  
  249. def getregentry():
  250.     return codecs.CodecInfo(name = 'punycode', encode = Codec().encode, decode = Codec().decode, incrementalencoder = IncrementalEncoder, incrementaldecoder = IncrementalDecoder, streamwriter = StreamWriter, streamreader = StreamReader)
  251.  
  252.